类声明 内联成员函数 类与结构体 this指针 前向声明 嵌套类

发表于 | 分类于 |

类的声明

在关键字public后面声明，它们是类与外部的接口，任何外部函数都可以访问公有类型数据和函数。
在关键字private后面声明，只允许本类中的函数访问，而类外部的任何函数都不能访问。
在关键字protected后面声明，与private类似，其差别表现在继承与派生时对派生类的影响不同

内联成员函数

内联函数，编译的时候将代码直接嵌入到调用的地方，从而减少函数调用的开销，从而提高效率。内联只是对编译器的建议，实际上即使加了inline也不一定宏展开，比如遇到switch，for语句的时候就往往不会。

类内部实现的函数都是内联函数。若在类内部实现，inline关键字可加可不加；
在类外部实现，需加inline，如inline void Clock::SetHour(int hour) { }。

类与结构体

class与struct的区别：在未指定访问权限时，class默认的是私有的，struct默认是公有的

struct Test
{
    int X;//公有的
     ...
};

隐含的this指针

成员函数有一个隐含的附加形参，即指向该对象的指针，这个隐含的形参叫做this指针，编译器自动传递

使用this指针保证了每个对象可以拥有不同数值的数据成员，但处理这些成员的代码可以被所有对象共享

成员函数是只读的代码，由所有对象共享，并不占对象的存储空间，因为this指针指向当前对象，所以成员函数可以区分它所作用的对象是哪一个。

class A
{
public:
    int m;
    void print()
    {
        cout << "A" << endl;
    }
};

A *pa = 0;
pa->print();

相当于成员函数传递的this指针为0，那调用会出错吗？ 肯定是正确输出”A” 的，因为this为0表示没有对某个对象进行操作，而print里面确实没有对某 个对象成员进行操作，所以是可以运行的。

前向声明

C++中类必须先定义，才能够实例化。两个类需要相互引用头文件形成一个“环形”引用时会出错。这时候需要用到前向声明，前向声明的类不能实例，但可以定义指针或引用。

#ifndef _B_H_
#define _B_H_

class A;

class B
{
public:
    B(void);
    ~B(void);

    void fun(A &a)
    {

    }

    A *a_;      // 前向声明的类不能实例化对象
};

#endif // _B_H_

#ifndef _A_H_
#define _A_H_

#include "B.h"
class A
{
public:
    A(void);
    ~A(void);

    B b_;
};

#endif // _A_H_

嵌套类\局部类

嵌套类

外围类需要使用嵌套类对象作为底层实现，并且该嵌套类只用于外围类的实现，且同时可以对用户隐藏该底层实现。

从作用域的角度看，嵌套类被隐藏在外围类之中，该类名只能在外围类中使用。如果在外围类之外的作用域使用该类名时，需要加名字限定。
嵌套类中的成员函数可以在它的类体外定义。
嵌套类仅仅只是语法上的嵌入。嵌套类的成员函数对外围类的私有成员没有访问权，反之亦然。

#include <iostream>
using namespace std;

class Outer
{
public:
    class Inner
    {
    public:
        void Fun();
        //{
        //  cout<<"Inner::Fun ..."<<endl;
        //}
    };
public:
    Inner obj_;
    void Fun()
    {
        cout << "Outer::Fun ..." << endl;
        obj_.Fun();
    }
};

void Outer::Inner::Fun()
{
    cout << "Inner::Fun ..." << endl;
}

int main(void)
{
    Outer o;
    o.Fun();

    Outer::Inner i;
    i.Fun();
}

局部类(基本没用过，稍作了解)

类也可以定义在函数体内，这样的类被称为局部类。局部类只在定义它的局部域内可见。